﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using Framework.Common.Extention;
using System.IO;
namespace Framework.Common
{
    public static class EncryptHelper
    {
        /// <summary>
        /// MD5函数
        /// </summary>
        /// <param name="str">原始字符串</param>
        /// <returns>MD5结果</returns>
        public static string MD5(string str)
        {
            byte[] b = Encoding.UTF8.GetBytes(str);
            b = new MD5CryptoServiceProvider().ComputeHash(b);
            string ret = "";
            for (int i = 0; i < b.Length; i++)
                ret += b[i].ToString("x").PadLeft(2, '0');

            return ret;
        }

        /// <summary>
        /// SHA256函数
        /// </summary>
        /// /// <param name="str">原始字符串</param>
        /// <returns>SHA256结果</returns>
        public static string SHA256(string str)
        {
            byte[] SHA256Data = Encoding.UTF8.GetBytes(str);
            SHA256Managed Sha256 = new SHA256Managed();
            byte[] Result = Sha256.ComputeHash(SHA256Data);
            return Convert.ToBase64String(Result);  //返回长度为44字节的字符串
        }

        #region AES
        /// <summary> 
        /// 加密
        /// </summary> 
        public class AES
        {
            //默认密钥向量
            private static byte[] Keys = { 0x41, 0x72, 0x65, 0x79, 0x6F, 0x75, 0x6D, 0x79, 0x53, 0x6E, 0x6F, 0x77, 0x6D, 0x61, 0x6E, 0x3F };

            public static string Encode(string encryptString, string encryptKey)
            {
                encryptKey = encryptKey.CutString(32);
                encryptKey = encryptKey.PadRight(32, ' ');

                RijndaelManaged rijndaelProvider = new RijndaelManaged();
                rijndaelProvider.Key = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 32));
                rijndaelProvider.IV = Keys;
                ICryptoTransform rijndaelEncrypt = rijndaelProvider.CreateEncryptor();

                byte[] inputData = Encoding.UTF8.GetBytes(encryptString);
                byte[] encryptedData = rijndaelEncrypt.TransformFinalBlock(inputData, 0, inputData.Length);

                return Convert.ToBase64String(encryptedData);
            }

            public static string Decode(string decryptString, string decryptKey)
            {
                try
                {
                    decryptKey = decryptKey.CutString(32);
                    decryptKey = decryptKey.PadRight(32, ' ');

                    RijndaelManaged rijndaelProvider = new RijndaelManaged();
                    rijndaelProvider.Key = Encoding.UTF8.GetBytes(decryptKey);
                    rijndaelProvider.IV = Keys;
                    ICryptoTransform rijndaelDecrypt = rijndaelProvider.CreateDecryptor();

                    byte[] inputData = Convert.FromBase64String(decryptString);
                    byte[] decryptedData = rijndaelDecrypt.TransformFinalBlock(inputData, 0, inputData.Length);

                    return Encoding.UTF8.GetString(decryptedData);
                }
                catch
                {
                    return "";
                }

            }

        }
        #endregion

        #region des
        /// <summary> 
        /// 加密
        /// </summary> 
        public class DES
        {
            //默认密钥向量
            private static byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };

            /// <summary>
            /// DES加密字符串
            /// </summary>
            /// <param name="encryptString">待加密的字符串</param>
            /// <param name="encryptKey">加密密钥,要求为8位</param>
            /// <returns>加密成功返回加密后的字符串,失败返回源串</returns>
            public static string Encode(string encryptString, string encryptKey)
            {
                encryptKey = encryptKey.CutString(8);
                encryptKey = encryptKey.PadRight(8, ' ');
                byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 8));
                byte[] rgbIV = Keys;
                byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
                DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
                MemoryStream mStream = new MemoryStream();
                CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                cStream.Write(inputByteArray, 0, inputByteArray.Length);
                cStream.FlushFinalBlock();
                return Convert.ToBase64String(mStream.ToArray());

            }

            /// <summary>
            /// DES解密字符串
            /// </summary>
            /// <param name="decryptString">待解密的字符串</param>
            /// <param name="decryptKey">解密密钥,要求为8位,和加密密钥相同</param>
            /// <returns>解密成功返回解密后的字符串,失败返源串</returns>
            public static string Decode(string decryptString, string decryptKey)
            {
                try
                {
                    decryptKey = decryptKey.CutString(8);
                    decryptKey = decryptKey.PadRight(8, ' ');
                    byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
                    byte[] rgbIV = Keys;
                    byte[] inputByteArray = Convert.FromBase64String(decryptString);
                    DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();

                    MemoryStream mStream = new MemoryStream();
                    CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                    cStream.Write(inputByteArray, 0, inputByteArray.Length);
                    cStream.FlushFinalBlock();
                    return Encoding.UTF8.GetString(mStream.ToArray());
                }
                catch
                {
                    return "";
                }
            }


















            //public static string DecryptString(string strText, string key)
            //{
            //    try
            //    {
            //        byte[] buffer = new MD5CryptoServiceProvider().ComputeHash(Encoding.ASCII.GetBytes(key));
            //        TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
            //        provider.Key = buffer;
            //        provider.Mode = CipherMode.ECB;
            //        byte[] inputBuffer = Convert.FromBase64String(strText);
            //        return Encoding.ASCII.GetString(provider.CreateDecryptor().TransformFinalBlock(inputBuffer, 0, inputBuffer.Length));
            //    }
            //    catch (Exception ex)
            //    {
            //        throw new ApplicationException("解密字符串错误：" + key, ex);
            //    }
            //}

            //public static string DecryptUTF8String(string strText, string key)
            //{
            //    try
            //    {
            //        byte[] buffer = new MD5CryptoServiceProvider().ComputeHash(Encoding.UTF8.GetBytes(key));
            //        TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
            //        provider.Key = buffer;
            //        provider.Mode = CipherMode.ECB;
            //        byte[] inputBuffer = Convert.FromBase64String(strText);
            //        return Encoding.UTF8.GetString(provider.CreateDecryptor().TransformFinalBlock(inputBuffer, 0, inputBuffer.Length));
            //    }
            //    catch (Exception ex)
            //    {
            //        throw new ApplicationException("解密字符串错误：" + key, ex);
            //    }
            //}

            //public static string EncryptString(string strText, string key)
            //{
            //    try
            //    {
            //        byte[] buffer = new MD5CryptoServiceProvider().ComputeHash(Encoding.ASCII.GetBytes(key));
            //        TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
            //        provider.Key = buffer;
            //        provider.Mode = CipherMode.ECB;
            //        byte[] bytes = Encoding.ASCII.GetBytes(strText);
            //        string str = Convert.ToBase64String(provider.CreateEncryptor().TransformFinalBlock(bytes, 0, bytes.Length));
            //        provider = null;
            //        return str;
            //    }
            //    catch (Exception ex)
            //    {
            //        throw new ApplicationException("加密字符串错误：" + key, ex);
            //    }
            //}

            //public static string EncryptUTF8String(string strText, string key)
            //{
            //    try
            //    {
            //        byte[] buffer = new MD5CryptoServiceProvider().ComputeHash(Encoding.UTF8.GetBytes(key));
            //        TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
            //        provider.Key = buffer;
            //        provider.Mode = CipherMode.ECB;
            //        byte[] bytes = Encoding.UTF8.GetBytes(strText);
            //        string str = Convert.ToBase64String(provider.CreateEncryptor().TransformFinalBlock(bytes, 0, bytes.Length));
            //        provider = null;
            //        return str;
            //    }
            //    catch (Exception ex)
            //    {
            //        throw new ApplicationException("加密字符串错误：" + key, ex);
            //    }
            //}
        }
        #endregion
    }
}
